home *** CD-ROM | disk | FTP | other *** search
/ Amiga Format CD 7 / Amiga Format AFCD07 (Dec 1996, Issue 91).iso / serious / shareware / programming / aros / dos / matchpatternnocase.c < prev    next >
C/C++ Source or Header  |  1996-09-12  |  8KB  |  301 lines
  1. /*
  2.     (C) 1995-96 AROS - The Amiga Replacement OS
  3.     $Id: matchpatternnocase.c,v 1.1 1996/09/11 12:54:46 digulla Exp $
  4.     $Log: matchpatternnocase.c,v $
  5.     Revision 1.1  1996/09/11 12:54:46  digulla
  6.     A couple of new DOS functions from M. Fleischer
  7.  
  8.     Desc:
  9.     Lang: english
  10. */
  11. #include <exec/memory.h>
  12. #include <clib/exec_protos.h>
  13. #include <clib/utility_protos.h>
  14. #include <dos/dosextens.h>
  15. #include "dos_intern.h"
  16.  
  17. /*****************************************************************************
  18.  
  19.     NAME */
  20.     #include <clib/dos_protos.h>
  21.  
  22.     __AROS_LH2(BOOL, MatchPatternNoCase,
  23.  
  24. /*  SYNOPSIS */
  25.     __AROS_LHA(STRPTR, pat, D1),
  26.     __AROS_LHA(STRPTR, str, D2),
  27.  
  28. /*  LOCATION */
  29.     struct DosLibrary *, DOSBase, 162, Dos)
  30.  
  31. /*  FUNCTION
  32.     Similar to MatchPattern(), only case insensitive (see there for
  33.     more information). For use with ParsePatternNoCase().
  34.  
  35.     INPUTS
  36.  
  37.     RESULT
  38.  
  39.     NOTES
  40.  
  41.     EXAMPLE
  42.  
  43.     BUGS
  44.  
  45.     SEE ALSO
  46.     MatchPattern(), ParsePatternNoCase().
  47.  
  48.     INTERNALS
  49.  
  50.     HISTORY
  51.     29-10-95    digulla automatically created from
  52.                 dos_lib.fd and clib/dos_protos.h
  53.  
  54. *****************************************************************************/
  55. {
  56.     __AROS_FUNC_INIT
  57.     __AROS_BASE_EXT_DECL(struct DosLibrary *,DOSBase)
  58.  
  59.     STRPTR s;
  60.     LONG match=0;
  61.     struct markerarray ma, *macur=&ma, *cur2;
  62.     LONG macnt=0, cnt2;
  63.     ULONG level;
  64.     UBYTE a, b, c, t;
  65.     LONG error;
  66. #define ERROR(a) { error=(a); goto end; }
  67.  
  68.     ma.next=ma.prev=NULL;
  69.     for(;;)
  70.         switch(*pat)
  71.         {
  72.             case MP_MULT: /* _#(_a) */
  73.                 PUSH(0,++pat,str);
  74.                 level=1;
  75.                 for(;;)
  76.                 {
  77.                     c=*pat++;
  78.                     if(c==MP_MULT)
  79.                         level++;
  80.                     else if(c==MP_MULT_END)
  81.                         if(!--level)
  82.                             break;
  83.                 }
  84.                 break;
  85.             case MP_MULT_END: /* #(a_)_ */
  86.                 level=1;
  87.                 for(;;)
  88.                 {
  89.                     c=*--pat;
  90.                     if(c==MP_MULT_END)
  91.                         level++;
  92.                     else if(c==MP_MULT)
  93.                         if(!--level)
  94.                             break;
  95.                 }
  96.                 break;
  97.             case MP_NOT: /* _~(_a) */
  98.                 s=++pat;
  99.                 level=1;
  100.                 for(;;)
  101.                 {
  102.                     c=*s++;
  103.                     if(c==MP_NOT)
  104.                         level++;
  105.                     else if(c==MP_NOT_END)
  106.                         if(!--level)
  107.                             break;
  108.                 }
  109.                 PUSH(1,s,str);
  110.                 break;
  111.             case MP_NOT_END: /* ~(a_)_ */
  112.                 cnt2=macnt;
  113.                 cur2=macur;
  114.                 do
  115.                 {
  116.                     cnt2--;
  117.                     if(cnt2<0)
  118.                     {
  119.                         cnt2=127;
  120.                         cur2=cur2->prev;
  121.                     }
  122.                 }while(!cur2->marker[cnt2].type);
  123.                 if(!*str++)
  124.                 {
  125.                     macnt=cnt2;
  126.                     macur=cur2;
  127.                 }else
  128.                     if(str>cur2->marker[cnt2].str)
  129.                         cur2->marker[cnt2].str=str;
  130.                 POP(t,pat,str);
  131.                 if(t&&*str)
  132.                 { PUSH(1,pat,str+1); }
  133.                 break;
  134.             case MP_OR: /* ( */
  135.                 s=++pat;
  136.                 level=1;
  137.                 for(;;)
  138.                 {
  139.                     c=*s++;
  140.                     if(c==MP_OR)
  141.                         level++;
  142.                     else if(c==MP_OR_NEXT)
  143.                     {
  144.                         if(level==1)
  145.                         { PUSH(0,s,str); }
  146.                     }else if(c==MP_OR_END)
  147.                         if(!--level)
  148.                             break;
  149.                 }
  150.                 break;
  151.             case MP_OR_NEXT: /* | */
  152.                 pat++;
  153.                 level=1;
  154.                 for(;;)
  155.                 {
  156.                     c=*pat++;
  157.                     if(c==MP_OR)
  158.                         level++;
  159.                     else if(c==MP_OR_END)
  160.                         if(!--level)
  161.                             break;
  162.                 }
  163.                 break;
  164.             case MP_OR_END: /* ) */
  165.                 pat++;
  166.                 break;
  167.             case MP_SINGLE: /* ? */
  168.                 pat++;
  169.                 if(*str)
  170.                     str++;
  171.                 else
  172.                 {
  173.                     POP(t,pat,str);
  174.                     if(t&&*str)
  175.                     { PUSH(1,pat,str+1); }
  176.                 }
  177.                 break;
  178.             case MP_SET: /* [ */
  179.                 pat++;
  180.                 for(;;)
  181.                 {
  182.                     a=b=*pat++;
  183.                     if(a==MP_SET_END)
  184.                     {
  185.                         POP(t,pat,str);
  186.                         if(t&&*str)
  187.                         { PUSH(1,pat,str+1); }
  188.                         break;
  189.                     }
  190.                     if(a==MP_ESCAPE)
  191.                         a=b=*pat++ +0x80;
  192.                     else if(a==MP_DASH)
  193.                     {
  194.                         a=*pat++;
  195.                         if(a==MP_ESCAPE)
  196.                             a=*pat++ +0x80;
  197.                         b=*pat++;
  198.                         if(b==MP_ESCAPE)
  199.                             b=*pat++ +0x80;
  200.                     }
  201.                     c=ToLower(*str);
  202.                     if(c>=a&&c<=b)
  203.                     {
  204.                         str++;
  205.                         while(*pat++!=MP_SET_END)
  206.                             ;
  207.                         break;
  208.                     }
  209.                 }
  210.                 break;
  211.             case MP_NOT_SET: /* [~ */
  212.                 if(!*str)
  213.                 {
  214.                     POP(t,pat,str);
  215.                     if(t&&*str)
  216.                     { PUSH(1,pat,str+1); }
  217.                     break;
  218.                 }
  219.                 pat++;
  220.                 for(;;)
  221.                 {
  222.                     a=b=*pat++;
  223.                     if(a==MP_SET_END)
  224.                     {
  225.                         str++;
  226.                         break;
  227.                     }
  228.                     if(a==MP_ESCAPE)
  229.                         a=b=*pat++ +0x80;
  230.                     else if(a==MP_DASH)
  231.                     {
  232.                         a=*pat++;
  233.                         if(a==MP_ESCAPE)
  234.                             a=*pat++ +0x80;
  235.                         b=*pat++;
  236.                         if(b==MP_ESCAPE)
  237.                             b=*pat++ +0x80;
  238.                     }
  239.                     c=ToLower(*str);
  240.                     if(c>=a&&c<=b)
  241.                     {
  242.                         POP(t,pat,str);
  243.                         if(t&&*str)
  244.                         { PUSH(1,pat,str+1); }
  245.                         break;
  246.                     }
  247.                 }
  248.                 break;
  249.             case MP_ALL: /* #? */
  250.                 /* This often used pattern has extra treatment to be faster */
  251.                 if(*str)
  252.                 { PUSH(0,pat,str+1); }
  253.                 pat++;
  254.                 break;
  255.             case 0:
  256.                 if(!*str)
  257.                 {
  258.                     match=1;
  259.                     ERROR(0);
  260.                 }else
  261.                 {
  262.                     POP(t,pat,str);
  263.                     if(t&&*str)
  264.                     { PUSH(1,pat,str+1); }
  265.                 }
  266.                 break;
  267.             case MP_ESCAPE:
  268.                 pat++;
  269.                 if(0x80+*pat++==*str)
  270.                     str++;
  271.                 else
  272.                 {
  273.                     POP(t,pat,str);
  274.                     if(t&&*str)
  275.                     { PUSH(1,pat,str+1); }
  276.                 }
  277.                 break;
  278.             default:
  279.                 if(*pat++==ToLower(*str))
  280.                     str++;
  281.                 else
  282.                 {
  283.                     POP(t,pat,str);
  284.                     if(t&&*str)
  285.                     { PUSH(1,pat,str+1); }
  286.                 }
  287.                 break;
  288.         }
  289. end:
  290.     macur=ma.next;
  291.     while(macur!=NULL)
  292.     {
  293.         struct markerarray *next=macur->next;
  294.         FreeMem(macur,sizeof(struct markerarray));
  295.         macur=next;
  296.     }
  297.     ((struct Process *)FindTask(NULL))->pr_Result2=error;
  298.     return match;
  299.     __AROS_FUNC_EXIT
  300. } /* MatchPatternNoCase */
  301.